package com.beantools.util.jsonutil;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.beantools.execption.JSONException;
import com.beantools.factory.format.JsonFormat;
import com.beantools.file.JsonFile;

import java.io.File;
import java.io.IOException;
import java.util.List;

import static com.beantools.constants.SingleChar.EN_POINT;
import static com.beantools.constants.SingleChar.INVERSE_LEAN;
import static com.beantools.util.ObjectUtil.isNotNull;
import static com.beantools.util.ObjectUtil.isNull;
import static com.beantools.util.StringUtil.*;

/**
 * 这是处理<code>json</code>对象的工具类，比如从文件中读取<code>json</code>并将其转化为
 * <code>jsonObject</code>对象，或者<code>List</code>容器对象，或者<code>
 * javabean</code>对象的方式存储。
 * <p>
 * 这个工具将在以后的公司开发的插件中使用。
 *
 * @author baoya
 * @version 1.0
 * @since 1.1.0
 */
@SuppressWarnings("all")
public class JSONImportUtil<T> extends JSONUtil {

    private static int INITIAL_CAPACITY = 10;

    /**
     * 这是根据文件路径<code>path</code>和文件名<code>fileName</code>读取文件中的<code>
     * json</code>字符串。
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonOne()}
     * <p>
     * 上面的代码输出的是<strong>first.json</strong>文件中的数据,如果想要格式化输出，可以调用这个方法：
     * <pre>
     *     <code>
     *          String string ="{\"name\":\"安若曦\",\"age\":\"22\",\"friends\":[{\"name\":\"陈希尔\",\"age\":\"22\"},{\"name\":\"安若曦\",\"age\":\"23\"},{\"name\":\"张立而\",\"age\":\"24\"}],\"address\":{\"province\":\"浙江省\",\"city\":\"杭州市\",\"county\":\"西湖区\",\"detail\":\"文三路\"}}";
     *          System.out.println(JsonFormat.getInstance(string).format());
     *     </code>
     * </pre>
     *
     * @param path     这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop</strong>
     * @param fileName 文件名字，包含文件的后缀名，比如<strong>first.json</strong>
     * @return 如果文件中有数据，或者读取文件不报错，则会返回文件中的内容
     */
    public static String fileToJsonString(String path, String fileName) throws IOException {
        return JsonFormat.noFormatJSON(JsonFile.getInstance().importJson(path, fileName));
    }

    /**
     * 这是根据文件路径<code>path</code>读取文件中的<code>json</code>字符串。
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTwo()}
     * 上面的代码输出的是<strong>first.json</strong>文件中的数据,如果想要格式化输出，可以调用这个方法：
     * <pre>
     *     <code>
     *          String string ="{\"name\":\"安若曦\",\"age\":\"22\",\"friends\":[{\"name\":\"陈希尔\",\"age\":\"22\"},{\"name\":\"安若曦\",\"age\":\"23\"},{\"name\":\"张立而\",\"age\":\"24\"}],\"address\":{\"province\":\"浙江省\",\"city\":\"杭州市\",\"county\":\"西湖区\",\"detail\":\"文三路\"}}";
     *          System.out.println(JsonFormat.getInstance(string).format());
     *     </code>
     * </pre>
     *
     * @param path 文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop\\third.json</strong>
     * @return 如果文件中有数据，或者读取文件不报错，则会返回文件中的内容
     */
    public static String fileToJsonString(String path) throws IOException {
        return JsonFormat.noFormatJSON(JsonFile.getInstance().importJson(path));

    }

    /**
     * 这是根据文件<code>file</code>读取文件中的<code>json</code>字符串。
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonThree()}
     * 上面的代码输出的是<strong>first.json</strong>文件中的数据,如果想要格式化输出，可以调用这个方法：
     * <pre>
     *     <code>
     *          String string ="{\"name\":\"安若曦\",\"age\":\"22\",\"friends\":[{\"name\":\"陈希尔\",\"age\":\"22\"},{\"name\":\"安若曦\",\"age\":\"23\"},{\"name\":\"张立而\",\"age\":\"24\"}],\"address\":{\"province\":\"浙江省\",\"city\":\"杭州市\",\"county\":\"西湖区\",\"detail\":\"文三路\"}}";
     *          System.out.println(JsonFormat.getInstance(string).format());
     *     </code>
     * </pre>
     *
     * @param file 文件的实例化对象
     * @return 如果文件中有数据，或者读取文件不报错，则会返回文件中的内容
     */
    public static String fileToJsonString(File file) throws IOException {
        return JsonFormat.noFormatJSON(JsonFile.getInstance().importJson(file));
    }


    /**
     * 这是根据文件路径<code>path</code>和文件名<code>fileName</code>读取文件中的<code>
     * json</code>数组，数组必须以<strong style="color: red"> [ </strong>开头，并以
     * <strong style="color: red"> ] </strong>结束。
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonFour()}
     * 上面的代码输出的是<strong>first.json</strong>文件中的数组,如果想要转化为<code>javabean</code>集合，
     * 可以调用这个方法：
     * <pre>
     *     <code>
     *           JSONArray jsonArray = JSONUtil.fileToJSONArray(filePath, fileName);
     *           System.out.println(jsonArray.toJavaList(Address.class));
     *     </code>
     * </pre>
     * 或者调用本类中的该方法{@link this#fileToObjects(Class, String, String)}
     *
     * @param path     这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop</strong>
     * @param fileName 文件名字，包含文件的后缀名，比如<strong>first.json</strong>
     * @return 如果文件中有数据，或者读取文件不报错，则会返回文件中的内容
     */
    public static JSONArray fileToJSONArray(String path, String fileName) throws IOException {
        path = JsonFile.getInstance().getRealPath(path, false, fileName);
        return fileToJSONArray(path);
    }

    /**
     * 这是根据文件路径<code>path</code>和文件名<code>fileName</code>读取文件中的<code>json</code>字符串并
     * 结合类<code>tClass</code>变量生成<code>javabean</code>对象的集合的方法，如代码所示：
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonFive()}
     * 数组必须以<strong style="color: red"> [ </strong>开头，并以<strong style="color: red"> ] </strong>结束，

     * <pre>
     *     <code>
     *          [
     *              {"province":"浙江省","city":"杭州市","county":"西湖区","detail":"文三路"},
     *              {"province":"安徽省","city":"阜阳市","county":"颍上县","detail":"人民路"}
     *          ]
     *     </code>
     * </pre>
     *
     * @param tClass   这是待生成的实体类的类变量，比如<code>String.class</code>
     * @param path     这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop</strong>
     * @param fileName 文件名字，包含文件的后缀名，比如<strong>first.json</strong>
     * @return 如果文件中有数据，或者读取文件不报错，则会返回文件中的内容
     */
    public static <T> List<T> fileToObjects(Class<T> tClass, String path, String fileName) throws IOException {
        if (isNull(tClass)) {
            throw new JSONException("实体类不能为空");
        }
        return fileToJSONArray(path, fileName).toJavaList(tClass);
    }

    /**
     * 这是根据文件路径<code>path</code>读取文件中的<code>json</code>字符串并结合类<code>tClass</code>变量
     * 生成<code>javabean</code>对象的集合的方法，如以下代码所示：
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonSix()}
     * 数组必须以<strong style="color: red"> [ </strong>开头，并以<strong style="color: red"> ] </strong>结束，
     * <pre>
     *     <code>
     *          [
     *              {"province":"浙江省","city":"杭州市","county":"西湖区","detail":"文三路"},
     *              {"province":"安徽省","city":"阜阳市","county":"颍上县","detail":"人民路"}
     *          ]
     *     </code>
     * </pre>
     *
     * @param tClass 这是待生成的实体类的类变量，比如<code>String.class</code>
     * @param path   文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop\\third.json</strong>
     * @return 如果文件中有数据，或者读取文件不报错，则会返回文件中的内容
     */
    public static <T> List<T> fileToObjects(Class<T> tClass, String path) throws IOException {
        return fileToObjects(tClass, new File(path));
    }

    /**
     * 这是根据文件<code>file</code>读取文件中的<code>json</code>字符串并结合类<code>tClass</code>变量
     * 生成<code>javabean</code>对象的集合的方法，如以下代码所示：
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonNine()}
     * 数组必须以<strong style="color: red"> [ </strong>开头，并以<strong style="color: red"> ] </strong>结束，

     * <pre>
     *     <code>
     *          [
     *              {"province":"浙江省","city":"杭州市","county":"西湖区","detail":"文三路"},
     *              {"province":"安徽省","city":"阜阳市","county":"颍上县","detail":"人民路"}
     *          ]
     *     </code>
     * </pre>
     *
     * @param tClass 这是待生成的实体类的类变量，比如<code>String.class</code>
     * @param file   文件的实例化对象
     * @return 如果文件中有数据，或者读取文件不报错，则会返回文件中的内容
     */
    public static <T> List<T> fileToObjects(Class<T> tClass, File file) throws IOException {
        return JSONArray.parseArray(getArrayJson(file), tClass);
    }

    /**
     * 这是根据文件路径<code>path</code>和读取文件中的<code>json</code>数组，数组必须以<strong style="color: red">
     * [ </strong>开头，并以<strong style="color: red"> ] </strong>结束。
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonSeven()}
     * 上面的代码输出的是<strong>first.json</strong>文件中的数组,如果想要转化为<code>javabean</code>集合，
     * 可以调用这个方法：
     * <pre>
     *     <code>
     *           JSONArray jsonArray = JSONUtil.fileToJSONArray(filePath, fileName);
     *           System.out.println(jsonArray.toJavaList(Address.class));
     *     </code>
     * </pre>
     * 或者调用本类中的该方法{@link this#fileToObjects(Class, String, String)}
     *
     * @param path 这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop/third.json</strong>
     * @return 如果文件中有数据，或者读取文件不报错，则会返回文件中的内容
     */
    public static JSONArray fileToJSONArray(String path) throws IOException {
        return fileToJSONArray(new File(path));
    }

    /**
     * 这是根据文件<code>file</code>和读取文件中的<code>json</code>数组，数组必须以<strong style="color: red">
     * [ </strong>开头，并以<strong style="color: red"> ] </strong>结束。
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonEight()}
     * 上面的代码输出的是<strong>first.json</strong>文件中的数组,如果想要转化为<code>javabean</code>集合，
     * 可以调用这个方法：
     * <pre>
     *     <code>
     *           JSONArray jsonArray = JSONUtil.fileToJSONArray(filePath, fileName);
     *           System.out.println(jsonArray.toJavaList(Address.class));
     *     </code>
     * </pre>
     * 或者调用本类中的该方法{@link this#fileToObjects(Class, String, String)}
     *
     * @param file 这是文件的对象
     * @return 如果文件中有数据，或者读取文件不报错，则会返回文件中的内容
     */
    public static JSONArray fileToJSONArray(File file) throws IOException {
        return JSONArray.parseArray(getArrayJson(file));
    }

    /**
     * 这是根据文件<code>path</code>和文件名<code>fileName</code>读取文件中的<code>json</code>数据，并生成
     * <code>jsonObject</code>对象，对象的{@code key}值是文件名去掉后缀名的名称。
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTen()}
     *
     * @param path     这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop</strong>
     * @param fileName 文件名字，包含文件的后缀名，比如<strong>first.json</strong>
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(String path, String fileName) {
        return fileToJsonObject(path, fileName, null);
    }

    /**
     * 这是根据文件<code>path</code>和文件名<code>fileName</code>读取文件中的<code>json</code>数据，并生成
     * <code>jsonObject</code>对象，对象的{@code key}值是文件名去掉后缀名的名称。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonEleven()}
     *
     * @param path       这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop</strong>
     * @param fileName   文件名字，包含文件的后缀名，比如<strong>first.json</strong>
     * @param jsonObject 调用者传递进来的<code>jsonobject</code>对象
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(String path, String fileName, JSONObject jsonObject) {
        return fileToJsonObject(path, fileName, jsonObject, null);
    }

    /**
     * 这是根据文件<code>path</code>和文件名<code>fileName</code>读取文件中的<code>json</code>数据，并生成
     * <code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTwelve()}
     *
     * @param path       这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop</strong>
     * @param fileName   文件名字，包含文件的后缀名，比如<strong>first.json</strong>
     * @param jsonObject 调用者传递进来的<code>jsonobject</code>对象
     * @param keyName    调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(String path, String fileName, JSONObject jsonObject, String keyName) {
        return fileToJsonObject(path, fileName, jsonObject, true, keyName);
    }

    /**
     * 这是根据文件<code>path</code>和文件名<code>fileName</code>读取文件中的<code>json</code>数据，并生成
     * <code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 同时，该方法有个<code>initialCapacity</code>参数，这是初始化新生成的<code>jsonobject</code>对象的容量值。
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonThirteen()}
     *
     * @param path            这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop</strong>
     * @param fileName        文件名字，包含文件的后缀名，比如<strong>first.json</strong>
     * @param jsonObject      调用者传递进来的<code>jsonobject</code>对象
     * @param initialCapacity 初始化<code>jsonobject</code>对象的容量值
     * @param keyName         调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(String path, String fileName, JSONObject jsonObject, int initialCapacity, String keyName) {
        return fileToJsonObject(path, fileName, jsonObject, initialCapacity, true, keyName);
    }

    /**
     * 这是根据文件<code>path</code>和文件名<code>fileName</code>读取文件中的<code>json</code>数据，并生成
     * <code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 同时，该方法有个<code>hashMap</code>参数，这是初始化新生成的<code>jsonobject</code>对象的内部选择哪种<code>map</code>
     * 存储。如果<code>hashMap</code>为true，其内部以<code>hashMap</code>的方式存储，否则，以<code>linkedHashMap</code>存储
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonFourteen()}
     *
     * @param path       这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop</strong>
     * @param fileName   文件名字，包含文件的后缀名，比如<strong>first.json</strong>
     * @param jsonObject 调用者传递进来的<code>jsonobject</code>对象
     * @param hashMap    这是<code>jsonobject</code>对象的存储方式
     * @param keyName    调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(String path, String fileName, JSONObject jsonObject, boolean hashMap, String keyName) {
        return fileToJsonObject(path, fileName, jsonObject, INITIAL_CAPACITY, hashMap, keyName);
    }

    /**
     * 这是根据文件<code>path</code>和文件名<code>fileName</code>读取文件中的<code>json</code>数据，并生成
     * <code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 同时，该方法有个<code>initialCapacity</code>参数，这是初始化新生成的<code>jsonobject</code>对象的容量值。
     * <p>
     * 同时，该方法有个<code>hashMap</code>参数，这是初始化新生成的<code>jsonobject</code>对象的内部选择哪种<code>map</code>
     * 存储。如果<code>hashMap</code>为true，其内部以<code>hashMap</code>的方式存储，否则，以<code>linkedHashMap</code>存储
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonFifteen()}
     *
     * @param path            这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop</strong>
     * @param fileName        文件名字，包含文件的后缀名，比如<strong>first.json</strong>
     * @param jsonObject      调用者传递进来的<code>jsonobject</code>对象
     * @param initialCapacity 初始化<code>jsonobject</code>对象的容量值
     * @param hashMap         这是<code>jsonobject</code>对象的存储方式
     * @param keyName         调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(String path, String fileName, JSONObject jsonObject, int initialCapacity, boolean hashMap, String keyName) {
        if (isEmpty(path)) {
            throw new JSONException("文件路径不能为空");
        }
        if (isEmpty(fileName)) {
            throw new JSONException("文件名称不能为空");
        }
        path = JsonFile.getInstance().getFilePath(path + INVERSE_LEAN + fileName);
        return fileToJsonObject(jsonObject, path, initialCapacity, hashMap, keyName);

    }

    /**
     * 这是根据文件路径<code>path</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonSixteen()}
     *
     * @param jsonObject 调用者传递进来的<code>jsonobject</code>对象
     * @param path       这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop/third.json</strong>
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, String path) {
        return fileToJsonObject(jsonObject, path, null);
    }

    /**
     * 这是根据文件路径<code>path</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象，
     * 对象的{@code key}值是文件名去掉后缀名的名称。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonSeventeen()}
     *
     * @param jsonObject 调用者传递进来的<code>jsonobject</code>对象
     * @param path       这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop/third.json</strong>
     * @param keyName    调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, String path, String keyName) {
        return fileToJsonObject(jsonObject, path, true, keyName);
    }

    /**
     * 这是根据文件路径<code>path</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 同时，该方法有个<code>hashMap</code>参数，这是初始化新生成的<code>jsonobject</code>对象的内部选择哪种<code>map</code>
     * 存储。如果<code>hashMap</code>为true，其内部以<code>hashMap</code>的方式存储，否则，以<code>linkedHashMap</code>存储
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonEighteen()}
     *
     * @param jsonObject 调用者传递进来的<code>jsonobject</code>对象
     * @param path       这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop/third.json</strong>
     * @param hashMap    这是<code>jsonobject</code>对象的存储方式
     * @param keyName    调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, String path, boolean hashMap, String keyName) {
        return fileToJsonObject(jsonObject, path, INITIAL_CAPACITY, hashMap, keyName);
    }

    /**
     * 这是根据文件路径<code>path</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 同时，该方法有个<code>initialCapacity</code>参数，这是初始化新生成的<code>jsonobject</code>对象的容量值。
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonNineteen()}
     *
     * @param jsonObject      调用者传递进来的<code>jsonobject</code>对象
     * @param path            这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop/third.json</strong>
     * @param initialCapacity 初始化新生成的<code>jsonobject</code>对象的容量值
     * @param keyName         调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, String path, int initialCapacity, String keyName) {
        return fileToJsonObject(jsonObject, path, initialCapacity, true, keyName);
    }

    /**
     * 这是根据文件路径<code>path</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 同时，该方法有个<code>initialCapacity</code>参数，这是初始化新生成的<code>jsonobject</code>对象的容量值。
     * <p>
     * 同时，该方法有个<code>hashMap</code>参数，这是初始化新生成的<code>jsonobject</code>对象的内部选择哪种<code>map</code>
     * 存储。如果<code>hashMap</code>为true，其内部以<code>hashMap</code>的方式存储，否则，以<code>linkedHashMap</code>存储
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTwenty()}
     *
     * @param jsonObject      调用者传递进来的<code>jsonobject</code>对象
     * @param path            这是文件的根路径，比如<strong>C:\\Users\\Administrator\\Desktop/third.json</strong>
     * @param initialCapacity 初始化<code>jsonobject</code>对象的容量值
     * @param hashMap         这是<code>jsonobject</code>对象的存储方式
     * @param keyName         调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, String path, int initialCapacity, boolean hashMap, String keyName) {
        return fileToJsonObject(jsonObject, new File(path), initialCapacity, hashMap, keyName);
    }

    /**
     * 这是根据文件的实例化对象<code>file</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTwentyOne()}
     *
     * @param file 文件的实例化对象
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(File file) {
        return fileToJsonObject(null, file, INITIAL_CAPACITY, true, null);
    }

    /**
     * 这是根据文件的实例化对象<code>file</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTwentyOne()}
     *
     * @param jsonObject 调用者传递进来的<code>jsonobject</code>对象
     * @param file       文件的实例化对象
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, File file) {
        return fileToJsonObject(jsonObject, file, INITIAL_CAPACITY, true, null);
    }

    /**
     * 这是根据文件的实例化对象<code>file</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTwentyTwo()}
     *
     * @param jsonObject 调用者传递进来的<code>jsonobject</code>对象
     * @param file       文件的实例化对象
     * @param keyName    调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, File file, String keyName) {
        return fileToJsonObject(jsonObject, file, INITIAL_CAPACITY, true, keyName);
    }

    /**
     * 这是根据文件的实例化对象<code>file</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>hashMap</code>参数，这是初始化新生成的<code>jsonobject</code>对象的内部选择哪种<code>map</code>
     * 存储。如果<code>hashMap</code>为true，其内部以<code>hashMap</code>的方式存储，否则，以<code>linkedHashMap</code>存储
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>

     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTwentyThree()}
     *
     * @param jsonObject 调用者传递进来的<code>jsonobject</code>对象
     * @param file       文件的实例化对象
     * @param hashMap    这是<code>jsonobject</code>对象的存储方式
     * @param keyName    调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, File file, boolean hashMap, String keyName) {
        return fileToJsonObject(jsonObject, file, INITIAL_CAPACITY, hashMap, keyName);
    }

    /**
     * 这是根据文件的实例化对象<code>file</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>initialCapacity</code>参数，这是初始化新生成的<code>jsonobject</code>对象的容量值。
     * <p>
     * 同时，该方法有个<code>keyName</code>参数，这是新生成的<code>jsonobject</code>对象的{@code key}值。如果该值不传
     * 则以文件名并去掉后缀名作为其{@code key}值，否则，就以该调用者传来的<code>keyName</code>值作为其{@code key}值。
     * <p>

     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTwentyFour()}
     *
     * @param jsonObject      调用者传递进来的<code>jsonobject</code>对象
     * @param file            文件的实例化对象
     * @param initialCapacity 初始化<code>jsonobject</code>对象的容量值
     * @param keyName         调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, File file, int initialCapacity, String keyName) {
        return fileToJsonObject(jsonObject, file, initialCapacity, true, keyName);
    }

    /**
     * 这是根据文件的实例化对象<code>file</code>读取文件中的<code>json</code>数据，并生成<code>jsonObject</code>对象。
     * <p>
     * 如果原来的<code>jsonobject</code>对象不为空，就返回原来的对象；如果为空，则返回新的<code>jsonobject</code>
     * 对象。
     * <p>
     * 同时，该方法有个<code>hashMap</code>参数，这是初始化新生成的<code>jsonobject</code>对象的内部选择哪种<code>map</code>
     * 存储。如果<code>hashMap</code>为true，其内部以<code>hashMap</code>的方式存储，否则，以<code>linkedHashMap</code>存储
     * <p>
     * 同时，该方法有个<code>initialCapacity</code>参数，这是初始化新生成的<code>jsonobject</code>对象的容量值。
     * <p>
     * 请参考测试代码{@link com.beantools.util.jsonutil.JSONImportTest#testImportJsonTwentyFive()}
     * @param jsonObject      调用者传递进来的<code>jsonobject</code>对象
     * @param file            文件的实例化对象
     * @param initialCapacity 初始化<code>jsonobject</code>对象的容量值
     * @param hashMap         这是<code>jsonobject</code>对象的存储方式
     * @param keyName         调用者传递过来作为<code>jsonobject</code>{@code key}值的参数
     * @return 如果文件中有数据，或者读取文件不报错，则会返回<code>jsonObject对象</code>
     */
    public static JSONObject fileToJsonObject(JSONObject jsonObject, File file, int initialCapacity, boolean hashMap, String keyName) {
        try {
            String json = fileToJsonString(file);
            jsonObject = isNotNull(jsonObject) ? jsonObject : new JSONObject(initialCapacity, hashMap);
            String fileName = file.getName();
            if (fileName.contains(EN_POINT)) {
                fileName = fileName.substring(0, fileName.indexOf(EN_POINT));
            }
            if (isBlank(json)) {
                jsonObject.put(keyName, null);
                return jsonObject;
            }
            keyName = isNotEmpty(keyName) ? keyName : fileName;
            json = JsonFormat.noFormatJSON(json);
            jsonObject.put(keyName, json);
            return jsonObject;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}
